Dynamic duplication estimation for garbage collection

ABSTRACT

Embodiments are directed to perfect physical garbage collection (PPGC) process that dynamically estimates duplicate containers using a Bloom filter-based dead vector by scanning an index containing a mapping of fingerprints to a container ID for a plurality of containers; returning, for each fingerprint, a fingerprint sequence associating each fingerprint with a respective unique container ID, wherein a last entry of the sequence is preserved and the remaining entries are considered duplicates; and maintaining a duplicate array of counts of the duplicates indexed by container IDs, and wherein the duplicate array comprises a duplicate counter that keeps track of a number of live duplicated segments for each container, and further wherein a live segment is a live duplicate segment if a segment with a same fingerprint exists in another container with a higher container ID.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present application claims the benefit of the U.S. Provisional Application No. 62/399,685 entitled “Efficient Physical Garbage Collection” and filed on Sep. 26, 2016.

TECHNICAL FIELD

This invention relates generally to maintaining stored data, and more particularly to systems and methods for garbage collection that dynamically estimates duplication of memory segments to consolidate space within a data storage system.

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

Most storage systems that do not perform overwrite data in place need a mechanism for garbage collection (“GC”) that is, reclaiming storage that is no longer in use while preserving live data. Since the advent of “log-structured file systems”, there has been work to optimize the cost of cleaning the file system to consolidate live data and make room for large contiguous areas of new data to be written. Most past efforts in this area have been to optimize the input/output (I/O) costs, as any effort to read and rewrite data reduces the throughput available for new data.

With deduplicating storage systems there is an additional complication: that of identifying what data is live in the first place. As new data is written to a system, duplicate chunks are replaced with references to previously stored data, so it is essential to track such new references. Approaches that require the storage system to be read-only during GC eventually give way to more complicated real-time reference management, using techniques such as epochs to control referential integrity.

Deduplicating systems face other challenges with respect to GC. As workloads evolve, some systems experience very different usage than traditional deduplicating backup storage systems were intended to support. Advanced backup systems are designed to handle a relatively low number (thousands) of relatively large files (Gigabytes), namely the full and incremental backups that have been the mainstay of computer backups for decades. In addition, the expectation is that the logical space, i.e., the set of files that could be written and read by applications such as a backup application, would only be a relatively small factor larger than the physical space, i.e., the storage consumed after deduplication. Typical deduplication ratios have been assumed to be in the neighborhood of 10-20 times or less, but this has been changing dramatically in some environments. Thus, new technology trends are increasing the deduplication ratio as well as the numbers of files represented in storage systems.

One current system uses a mark-and-sweep algorithm that determines the set of live chunks reachable from the live files and then frees up unreferenced space. There are also other alternatives such as reference counting.

In prior systems, GC was performed at the logical level, meaning the system analyzed each file to determine the set of live chunks in the storage system. The shift to using individual file-level backups, rather than tar-like aggregates, meant that the number of files in some systems increased dramatically. This resulted in high GC overhead during the mark phase, especially due to the amount of random I/O required. At the same time, the high deduplication ratios in some systems resulted in the same live chunks being repeatedly identified, again resulting in high GC overhead. The time to complete a single cycle of GC in such systems could be on the order of several days. Since backing up data concurrently with GC results in contention for disk I/O and processing, there is a significant performance implication to such long GC cycles; in addition, a full system might run out of capacity while awaiting space to be reclaimed.

Therefore, there is a need to redesign GC to work at the physical level: instead of GC enumerating all live files and their referenced chunks, entailing random access to all files, GC performs a series of sequential passes through the physical storage containers containing numerous chunks. Because the I/O pattern is sequential and because it scales with the physical capacity rather than the deduplication ratio or the number of individual files, the overhead is relatively constant and proportional to the size of the system.

The subject matter discussed in the background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the background section merely represents different approaches, which in and of themselves may also be inventions. EMC, Data Domain, Data Domain Restorer, and Data Domain Boost are trademarks of Dell EMC Corporation.

BRIEF DESCRIPTION OF THE DRAWINGS

In the following drawings like reference numerals designate like structural elements. Although the figures depict various examples, the one or more embodiments and implementations described herein are not limited to the examples depicted in the figures.

FIG. 1 is a diagram of a large-scale network implementing a dynamic duplicate estimation process for a perfect physical garbage collection system, under some embodiments.

FIG. 2 shows a typical file tree representation in deduplicated storage.

FIG. 3 is a flowchart illustrating method steps for a standard PGC method that is enhanced by certain PPGC techniques under some embodiments.

FIG. 4 is a flowchart illustrating method steps for a PPGC method, under some embodiments.

FIG. 5 illustrates a Perfect Hash Function for a fingerprint set that can be used in conjunction with certain embodiments.

FIG. 6 illustrates a correlation of index buckets to PHF buckets, under an embodiment.

FIG. 7 illustrates a composition of the Live and Live Instance vectors for GC, PGC, and PPGC processes under some embodiments.

FIG. 8 illustrates an example of how a live instance vector in PGC is used to track the unique live segments.

FIGS. 9A and 9B illustrate a copy forward procedure on an example segment of a Live Vector, under some embodiments.

FIG. 10 is a system block diagram of a computer system used to execute one or more software components of the PPGC process, under some embodiments.

DETAILED DESCRIPTION

A detailed description of one or more embodiments is provided below along with accompanying figures that illustrate the principles of the described embodiments. While aspects of the invention are described in conjunction with such embodiment(s), it should be understood that it is not limited to any one embodiment. On the contrary, the scope is limited only by the claims and the invention encompasses numerous alternatives, modifications, and equivalents. For the purpose of example, numerous specific details are set forth in the following description in order to provide a thorough understanding of the described embodiments, which may be practiced according to the claims without some or all of these specific details. For the purpose of clarity, technical material that is known in the technical fields related to the embodiments has not been described in detail so that the described embodiments are not unnecessarily obscured.

It should be appreciated that the described embodiments can be implemented in numerous ways, including as a process, an apparatus, a system, a device, a method, or a computer-readable medium such as a computer-readable storage medium containing computer-readable instructions or computer program code, or as a computer program product, comprising a computer-usable medium having a computer-readable program code embodied therein. In the context of this disclosure, a computer-usable medium or computer-readable medium may be any physical medium that can contain or store the program for use by or in connection with the instruction execution system, apparatus or device. For example, the computer-readable storage medium or computer-usable medium may be, but is not limited to, a random access memory (RAM), read-only memory (ROM), or a persistent store, such as a mass storage device, hard drives, CDROM, DVDROM, tape, erasable programmable read-only memory (EPROM or flash memory), or any magnetic, electromagnetic, optical, or electrical means or system, apparatus or device for storing information. Alternatively or additionally, the computer-readable storage medium or computer-usable medium may be any combination of these devices or even paper or another suitable medium upon which the program code is printed, as the program code can be electronically captured, via, for instance, optical scanning of the paper or other medium, then compiled, interpreted, or otherwise processed in a suitable manner, if necessary, and then stored in a computer memory. Applications, software programs or computer-readable instructions may be referred to as components or modules. Applications may be hardwired or hard coded in hardware or take the form of software executing on a general purpose computer or be hardwired or hard coded in hardware such that when the software is loaded into and/or executed by the computer, the computer becomes an apparatus for practicing the invention. Applications may also be downloaded, in whole or in part, through the use of a software development kit or toolkit that enables the creation and implementation of the described embodiments. In this specification, these implementations, or any other form that the invention may take, may be referred to as techniques. In general, the order of the steps of disclosed processes may be altered within the scope of the invention.

Some embodiments of the invention involve software development and deployment in a distributed system, such as a very large-scale wide area network (WAN), metropolitan area network (MAN), or cloud based network system, however, those skilled in the art will appreciate that embodiments are not limited thereto, and may include smaller-scale networks, such as LANs (local area networks). Thus, aspects of the one or more embodiments described herein may be implemented on one or more computers executing software instructions, and the computers may be networked in a client-server arrangement or similar distributed computer network.

Embodiments are described for a physical garbage collection system that uses a memory efficient perfect hash vector to track live segments along with a new duplicate removal algorithm to eliminate the sampling phases required by present GC methods. FIG. 1 illustrates a computer network system that implements one or more embodiments of a large-scale network implementing an efficient or “perfect” physical garbage collection process, under some embodiments. In system 100, a backup server 102 executes a backup management process 112 that coordinates or manages the backup of data from one or more data sources 108 to storage devices, such as network storage 114, client storage 106, and/or virtual storage devices 104. With regard to virtual storage 114, any number of virtual machines (VMs) or groups of VMs may be provided to serve as backup targets, and the target VMs may also be organized into one or more vCenters (virtual centers) representing a physical or virtual network of many virtual machines. The VMs or other network storage devices serve as target storage devices for data backed up from one or more data sources, such as computer 108, which may have attached local storage 118 or utilize networked accessed storage devices 114.

The network server computers are coupled directly or indirectly to the target VMs 104 and 106, and to the data source 108 through network 110, which may be a cloud network, LAN, WAN or other appropriate network. Network 110 provides connectivity to the various systems, components, and resources of system 100, and may be implemented using protocols such as Transmission Control Protocol (TCP) and/or Internet Protocol (IP), well known in the relevant arts. In a distributed network environment, network 110 may represent a cloud-based network environment in which applications, servers and data are maintained and provided through a centralized cloud-computing platform. In an embodiment, system 100 may represent a multi-tenant network in which a server computer runs a single instance of a program serving multiple clients (tenants) in which the program is designed to virtually partition its data so that each client works with its own customized virtual application, with each VM representing virtual clients that may be supported by one or more servers within each VM, or other type of centralized network server.

The data generated or sourced by system 100 may be stored in any number of persistent storage locations and devices, such as local client storage, server storage (e.g., 118). The backup process 112 causes or facilitates the backup of this data to other storage devices of the network, such as network storage 114, which may at least be partially implemented through storage device arrays, such as RAID components. In an embodiment network 100 may be implemented to provide support for various storage architectures such as storage area network (SAN), Network-attached Storage (NAS), or Direct-attached Storage (DAS) that make use of large-scale network accessible storage devices 114, such as large capacity disk (optical or magnetic) arrays. In an embodiment, the target storage devices, such as disk array 114 may represent any practical storage device or set of devices, such as fiber-channel (FC) storage area network devices, and OST (OpenStorage) devices. In an embodiment, a one or more dedicated client storage machines 106 may be provided with access to local storage media 116 or an interface to the network storage 114.

The data sourced by the data source may be any appropriate data, such as database data that is part of a database management system. In this case, the data may reside on one or more hard drives (e.g., 118) and may be stored in the database in a variety of formats. One example is an Extensible Markup Language (XML) database, which is a data persistence software system that allows data to be stored in XML format. Another example is a relational database management system (RDMS), which uses tables to store the information. A separate computer 106 may represent a database server that instantiates a program that interacts with the database. Each instance of a database server may, among other features, independently query the database and store information in the database, or it may be an application server that provides user interfaces to database servers, such as through web-based interface applications or through virtual database server or a virtual directory server applications.

In an embodiment, system 100 may represent a Data Domain Restorer (DDR)-based deduplication storage system, and storage server 128 may be implemented as a DDR Deduplication Storage server provided by EMC Corporation. However, other similar backup and storage systems are also possible. System 100 may utilize certain protocol-specific namespaces that are the external interface to applications and include NFS (network file system) and CIFS (common internet file system) namespaces, as well as DD Boost provided by EMC Corporation. In general, DD Boost (Data Domain Boost) is a system that distributes parts of the deduplication process to the backup server or application clients, enabling client-side deduplication for faster, more efficient backup and recovery.

Garbage Collection Processing

As shown in FIG. 1, system 100 includes a perfect physical garbage collection process 120 associated with or executed as part of the backup management process 112. With reference to the backup system of FIG. 1, or similar backup systems, freeing unreferenced space is a basic storage system operation. While there are multiple ways space management is implemented in traditional storage, when a file is deleted, generally blocks referenced from its inodes can be freed immediately by marking a free bitmap or inserting entries into a free list. For deduplicated storage, determining which chunks are referenced has added complexity as a chunk may have numerous references both within a single file and across many files written at various times. While some deduplication methods assumed a First In First Out (“FIFO”) deletion pattern, file deletion can generally be in any order.

There are a number of properties to consider when designing and evaluating a garbage collection algorithm: (1) All referenced chunks should be preserved so user data can be retrieved; (2) Most unreferenced chunks should be removed to free space; (3) The system should support client reads and writes during garbage collection; and (4) System overheads should be minimized.

Embodiments described herein utilize the fact that most unreferenced chunks should be removed instead of all, since it is often more efficient to focus cleaning on regions that are mostly unreferenced, rather than copying-forward numerous live chunks to reclaim a small amount of space. This is particularly relevant in log-structured storage systems commonly used by deduplicated storage, which tend to exhibit a bimodal distribution of container liveness, where containers tend to be mostly dead or mostly live.

A general garbage collection (GC) procedure can be summarized as follows in terms of steps it performs: (1) enumeration—identify all the live segments; (2) filter—remove duplicate segments—preserve the one with highest container ID; (3) select—compute the liveness of each container and determine the cutoff liveness percentage; and (4) copy—copy forward the live segments from the selected containers.

In many systems, there is not enough memory to track all of the live segments so a sampling procedure is needed to identify a candidate subset of containers before the GC procedure above can be performed. A general GC sampling procedure typically performs the following steps: (1) enumeration—identify all the live segments as limited to a subset of fingerprints; (2) filter—remove duplicate segments; (3) select—estimate the liveness of the containers based on the sampled set of fingerprints; and (4) candidate—insert all the segments of the selected containers into a candidate vector. The GC procedure is then performed on the subset of candidate fingerprints and containers. This means that the GC time is essentially doubled due to the need to perform both the sampling and GC procedures.

In present GC systems, two very large bloom filters of about equal size are used to track the live segments and the unique live segments. They are called the live vector and the live instance vector. During the enumeration phase, GC inserts live references into the live vector based on the fingerprint of the data segment. In one example, same data segments can exist in multiple containers and the live vector does not distinguish these duplicated segments. They are all represented by a set of bits in the Bloom filter. In the filter phase, for each fingerprint, the index returns a sequence of (fingerprint, container ID). The index maps a segment fingerprint to the container that contains the segment. In one example, a storage system keeps only the entry with the highest container ID, thus removing all the older duplicated segments. A new key is generated with both the fingerprint and the container ID and the key is inserted into the live instance vector. GC will only consider segments in the live instance vector live and everything else are dead segments that can be cleaned.

In addition to the time overhead mentioned above, this type of system presents significant memory overhead. Due to the memory requirement of these two large bloom filters, GC often cannot process all the fingerprints in the file system and it has to perform a sampling procedure, which essentially doubles the GC memory requirement.

FIG. 2 shows a typical file tree representation 200 in deduplicated storage. The chunks directly written by users are represented as L0, meaning the lowest level of the tree. Consecutive L0 chunks are referenced with an array of fingerprints by an L1 chunk, and an array of L1 fingerprints are referenced by an L2 chunk. This continues up to the top of the tree that we always label L6 for consistency, even if the file is small enough not to need intermediate nodes such as the example on the right side of the figure. The L1-L6 chunks are referred to as LP chunks, where P is a parameter that ranges from 1 to 6 and indicates meta data representing the file. Representing a file in a tree structure of fingerprints covering the lower layers of the tree is often called a Merkle tree. Deduplication takes place because a chunk can be referenced multiple times such as chunks A and B in the example. Though not shown in FIG. 2, LP chunks are themselves stored on disk in containers.

As an example, consider a system with 100 TB of capacity, 10 times deduplication ratio (logical capacity divided by physical capacity), 8 KB L0 chunks, and 20-byte fingerprints. The logical capacity is 1 PB, and since each 8 KB logically written by a client requires a 20-byte fingerprint stored in an L1, the L1 chunks are 2.5 TB, though the upper levels of the tree are smaller. This example highlights that the mark phase cannot be fully performed in memory, as the L1 references should be read from disk. In an embodiment, the system 100 container format includes a metadata section with a list of fingerprints for the chunks within the container. The metadata region is relatively small (a few hundred KB) and can be read more quickly than the full container

Physical Garbage Collection (PGC) was developed as a way to address performance issues with earlier Logical Garbage Collection (LGC) systems. Namely, the processing of small files requiring a lot of random reads on the segment tree, high deduplication ratios in the segment trees, and poor locality in the segment trees. FIG. 3 is a flowchart illustrating method steps for a standard PGC method that is enhanced by certain PPGC techniques under some embodiments. As shown in FIG. 3, standard PGC method 300 starts with a pre-merge step 302, in which it dumps the in-memory index to disk; this step may force an index merge. In step 304 it does a pre-analysis in which it walks the Index and creates a perfect hash vector. It then iterates through all files under a name space in a pre-enumeration step 306, in every segment is added to the live vector if it meets the pre-sampling criteria. In step 308 it does a pre-filter, which iterates through the fingerprint index and selects which instance of a given fingerprint should be preserved. One example policy is to preserve the most recently written copy of a fingerprint (i.e., the one stored in the latest container ID). The output of the phase is a bloom filter referred to as Live Instance Vector. In step 310 it does a pre-select that iterates through the containers, and uses the Live Instance Vector to estimate the percentage of the live data in each container. This step calculates the cleaning criteria/thresholds, and marks a container as candidate for cleaning if it meets the cleaning criteria.

Once the pre-phase steps 302 to 310 are performed, PGC method proceeds with a merge step 312 that is the same as the pre-merge 302 but at a later time. It can be skipped if no sampling is required. It then does an analysis step 312 that walks the index and creates a perfect hash vector. In candidate step 314 it iterates all containers marked in step 308 (pre-filter), and generates a bloom filter referred to as Candidate Vector with all the fingerprints in the candidate containers. Note that a Bloom filter of container IDs is not used because in the next step 316, the system enumerates the namespace and restrict the fingerprints to the candidate set and the file trees do not have the container ID at which a fingerprint is located. The enumeration step 316 is the same as the pre-enumeration 306 but it restricts the fingerprints to the candidate set rather than to the pre-sampling criteria. If no sampling is required, this step is skipped since pre-enumeration can consider all fingerprints. The filter step 318 is the same as pre-filter but it restricts the fingerprints to the candidate set rather than to the pre-sampling criteria. If no sampling is required, this phase is skipped. Copy step 320 copies all the candidate containers forward and use the Live Instance Vector to filter the segments that are being copied; and the summary step 322 rebuilds the summary vector whenever there is one for the corresponding backup system (e.g., DDR) model.

With respect to the enumeration algorithm for PGC, instead of traversing the segment tree of each file, PGC traverses the segment tree level by level. There may be up to 6 levels of the segment tree in certain backup systems (e.g., DD File System). PGC first traverses the namespace to identify all the live L6 (level 6) segments and insert them into the live vector. Then it scans the containers and reads all the live L6 segments and inserts all the L5 references into the live vector. The process is repeated until PGC has inserted all the live L0 references into the live vector. This algorithm always perform sequential read of the containers and it does not repeat reading the same container in case of high de-duplication ratio. PGC makes use of the perfect hash vector to track all the fingerprints in the segment tree up to the level. This perfect hash vector does not replace the live vector. The perfect hash vector can represent a known subset of fingerprints in the file system uniquely, i.e., there is no collision in the LP segments. The uniqueness property also allows PGC to compute a level by level checksum of the parent and child fingerprints to verify the consistency in the segment tree, which is implicit in the LGC algorithm. The memory requirement of the perfect hash vector in PGC is, for example, about 4.5 bits per fingerprint because it has to track 3 different states for each fingerprint. A simple perfect hash vector (without the consistency feature) only requires, for example, 2.8 bit per fingerprint. There is a cost to build the perfect hash vector. All the fingerprints in the system must be read and analyzed to build the hash functions. This process can take several hours. A significant problem with general PGC, is that sampling is still required on most customers' systems, which means that the system must run pre-phase operations, and the GC cycle is long.

Perfect Physical Garbage Collection

To overcome the sampling requirement and attendant processing/time overhead associated with PGC systems, embodiments of system 100 include a Perfect Physical Garbage Collection (“PPGC”) process that uses perfect hash vectors instead of large bloom filters for the live and live instance vectors.

FIG. 4 is a flowchart illustrating method steps for a PPGC method, under some embodiments. Process 400 begins with a merge step 402 that dumps the in-memory index to disk (this step may force an index merge). In the analysis step 404, it walks the index that contains the mapping of fingerprints to the container ID and builds a perfect hash function for both the walk vector and the live vector. A walk vector is used to assist a breadth-first search of the file segment trees instead of doing per file depth-first scans. It consists of a walk bit to indicate the segment is walked and a confirm bit to confirm that the segment is read during container scans for each level. A depth-first scan results in random I/O on disk for file metadata (Lps). To do a breadth-first scan, the process performs a series of sequential container scans, one scan for each level L6 to L1. It first records the live L6 fingerprints in the PHV based on files referenced in the namespace by setting a walk bit. In an embodiment, the system has an in-memory structure that records which Lp types (L6, L5, L0) exist in each container, so it can specifically scan containers with L6 chunks. If the L6 is marked as walk in the perfect hash vector, the confirm bit is marked, and the process then parses the L5 fingerprints stored in the L6 and sets the walk bits for those entries in the perfect hash vector. These steps are then repeated for scanning for L5 chunks, L4 chunks, and so on, until the L1 chunks are read.

For PPGC, the walk vector is similar to that used for PGC, but the Live Vector is a perfect hash vector, instead of the Bloom filter used in PGC. This step builds a per container duplicate counter at the same time. The duplicate count table keeps a mapping of <container ID, duplicate count> where duplicate count is the number of segments in the container that have duplicates across the system. In enumeration step 406, the process iterates through all files under the name space, and for every segment, the process adds it to the live vector. This step is similar to the PGC process, but here live segments are inserted in the perfect hash vector rather than the Bloom filter. The select step 408 iterates through the containers and uses the live vector and the duplicate counter to estimate the liveness of the container. It also calculates the true liveness of the container by considering the duplicates. In copy step 410, the process copies the live segment out of the selected containers. The process 400 ends with a summary step 322 that rebuilds the summary vector whenever there is one for the corresponding backup system (e.g., DDR) model.

As stated above, the PPGC process primarily distinguishes over the PGC process by using perfect hash vectors instead of Bloom filters for the Live Vector. In general, a perfect hash function is a collision free hash function that maps a set of keys of size n to a range of size m where m>n (m=1.43*n). For example, it only requires 2.8 bits per key in a data domain implementation, and is thus is much more compact than the Bloom filter, which requires 6 bits per fingerprint. However use of the perfect hash vector requires that the hash function should be pre-computed using the entire set of keys first and any key not in the initial set can cause collision. A description of perfect hash functions that provides background for the derivation of the 2.8 bits/fp possible in the PPGC system may be found in “Hash, Displace, and Compress” by Djamal Belazzougui, Fabiano Botelho, and Martin Dietzfelbinger (http:/cmph.sourceforge.net/papers/esa09.pdf).

In an embodiment, the PPGC process of FIG. 4 follows the same physical enumeration algorithm as PGC. It replaces the live vector bloom filter by a simple perfect hash live vector (2.8 bit per fingerprint). The smaller memory footprint and the elimination of the live instance vector allows PPGC to handle 6/2.8*2=4.28 times more fingerprints, so that the sampling procedure is no longer needed.

With regard to duplicate removal, duplicates are removed in the copy phase. Each time a segment is copied forward or left behind, the segment will be deleted from the live vector by flipping the bit in the perfect hash vector. Subsequent lookup of the same segment will return a dead status and the segment will be removed. If the copy phase begins from the highest container ID, essentially it will preserve the segment with the highest container ID and remove all the duplicates in the lower containers. This algorithm is not possible had the live vector been implemented as a Bloom filter because different live segments can collide and removal of one will cause the other one to become dead as well, but the perfect hash vector is collision free.

FIG. 5 illustrates a Perfect Hash Function for a fingerprint set that can be used in conjunction with certain embodiments. The perfect hash function phf( ) has the following representation: phf(x)=(f(x)+a h(x)+b)%m i(x)=g(x)%r where f, g, h are uniform hash functions; r is the number of hash buckets in the perfect hash function and a, b are constants that depend on the bucket. The size of the function can be written as: |PH _(vec) |=|PHF|+|Bit vector| where |PHF| is the space required to store the per bucket constants.

The index is further subdivided into multiple partitions such that all the fingerprints in each partition can fit in memory in order to build the perfect hash function for that subset of fingerprints. FIG. 6 illustrates a correlation of index buckets to PHF buckets, under an embodiment.

In the regular non-sampling phases of GC, all the GC memory is allocated for three very large data structures: (1) A perfect hash vector for LP segments (“LP PHVEC”); (2) A Live Vector (block bloom filter) for all the live fingerprints; and (3) A Live Instance Vector (block Bloom filter) to filter the duplicates. This structure is illustrated in data element 702 of FIG. 7, where FIG. 7 illustrates a composition of the Live and Live Instance vectors for GC, PGC, and PPGC processes under some embodiments. In FIG. 7, the element labeled “MISC” may include a collision-tracking Bloom filter (described in greater detail below), a live duplicate counter, copy buffers, and other similar elements.

In an example implementation, the PGC process allocates 6 bits per fingerprints to maintain a collision rate of 7% in the block Bloom filter. If N is the number of fingerprints in the system, the memory required for the live vector to support all N fingerprints would be N*6/8 bytes. On a large scale data domain system, the theoretical maximum number of fingerprints might be on the order of 135 billion with two times (2×) compression, which would require 135 billion*6/8=101 GB of memory. That means 202 GB for both the live vector and the live instance vector.

In an embodiment of the PPGC system, Bloom filters of the PGC block 702 for the Live Vector and the Live Instance Vector are replaced by perfect hash vectors, as shown in data element 704 of FIG. 7. This means they can support more than two times (2×) the number of fingerprints as it takes only 2.8 bit per fingerprint to build the perfect hash vector.

In an embodiment, the PPGC process adopts a dynamic duplicate removal algorithm in the copy phase, which does not require the Live Instance Vector, as shown in data element 706 of FIG. 7. This allows PPGC to support 4.2 to 4.4 times more fingerprints than PGC. In certain systems, this is enough to eliminate the sampling phases on all platforms and ASUP data also supports this conclusion.

The time required to build the live perfect hash vector would be prohibitive if a single thread is used to scan the index one bucket at a time. In an embodiment, multi-threading is used so that this index scan can be completed in a relatively short time.

Duplicate Removal

In general, among a plurality of fingerprints pointing to the same block locations, all fingerprints (e.g., FP1, FP2 and FP3) are considered live only if any one of them is live. However, the dynamic duplicate removal algorithm requires clearing the liveness bits in the live vector. Removing the liveness bit can make all of the fingerprints dead, which is a potential false negative scenario that can cause data corruption. Embodiments of the PPGC process includes mechanisms that help ensure that no data corruption can occur in this kind of situation.

FIG. 8 illustrates an example of how a Live Instance Vector 804 in PGC is used to track the unique live segments. Fingerprints can be XOR'ed with the highest container ID (CID) 802 that contains the fingerprint to form the key for this vector. All fingerprints in older containers of the Live Instance Vector 804 can be considered dead.

While this Live Instance Vector gives very precise information about the duplicates, it requires 6 bits per fingerprint. If there are N containers and 1024 segments in each L0 container, that consumes N*1024*6/8 bytes of memory.

In PPGC process of FIG. 1, this Live Instance Vector is not present. Duplicates can be removed by a combination of a per-container live duplicate counter and a dynamic duplicate removal algorithm in the copy phase. Only 2 bytes may be needed for each container to track the number of live duplicates. The live duplicate counter keeps track of the number of live duplicates in each container. By subtracting the number of live segments with this live duplicate count, the true liveness of the container is obtained, which allows the building of the liveness histogram and computing the cutoff point as follows: #live segments−#live segments that are duplicates=#live segments without duplicates

Duplicates can be removed dynamically in the copy forward procedure. Containers can be copied forward starting with the highest CID. The same algorithm can work if it starts from the lowest CID, except that duplicate segments with the lowest CID can be preserved. For each live segment copied forward or left behind, the fingerprint can be cleared from the live vector dynamically. Subsequent duplicates of those segments can be discarded because they can be considered dead once the bit is cleared.

One major distinction between PGC and PPGC is that in PPGC, the live duplicate segments are not known. In order to preserve the newest segments, the copy forward phase will be performed starting from the highest CID and then move backwards towards the lowest CID. Each time a segment is copied forward, all subsequent segments with the same fingerprint are duplicates. Therefore, the liveness bit of that segment can be cleared in the live vector, meaning that essentially the segment is now dead. The diagram of FIG. 9A illustrates an example of this procedure. As shown in FIG. 9A, the copy forward phase starts with the highest CID, which is CID2, and then moves backward to CID0. Each time a segment is copied forward, all subsequent segments of Live Vector 902 with the same fingerprint (FP) are duplicates.

Diagram 910 in FIG. 9B illustrates the situation where the fingerprint (FP) in CID2 is copied forward. In the copy phase, live segments in the candidate containers can be copied forward and all the segments (live or dead) in the non-candidate containers can be untouched and left behind. For the sake of simplicity, the term “copied forward” means copied forward or left behind whenever it makes sense.

The clearing of the liveness bit works because perfect hash vector maps each fingerprint uniquely to the vector. If a Bloom filter is used, removal of a liveness bit can also kill all other fingerprints that map to the same bit, which can cause missing segments. It should be noted that even a container is not a candidate, its meta data should still be read to perform the duplicate removal for all live segments that can be left behind in the container. For the embodiments described herein, a perfect hash vector replaces the Bloom filter for the Live Vector. This perfect hash vector can be built in a short time using multi threads in parallel. The existing LP perfect hash vector can still be preserved for LP verification. The entire index is scanned only once to build perfect hash functions for both the LP vector and the Live Vector.

Dynamic Duplicate Estimation

As described above, in a PGC system, two very large bloom filters of about equal size are used to track the live segments and the unique live segments in the live vector and the live instance vector. During the enumeration phase, GC inserts live references into the live vector based on the fingerprint of the data segment. In a DDFS (Data Domain File System), same data segments can exist in multiple containers and the live vector does not distinguish these duplicated segments. They are all represented by the same bit. In the filter phase, for each fingerprint, the index returns a sequence of (fingerprint, container ID). DDFS keeps only the entry with the highest container ID, thus removing all the older duplicated segments. A new key is generated with both the fingerprint and the container ID and the key is inserted into the live instance vector. GC will only consider segments in the live instance vector live and everything else are dead segments that can be cleaned. Due to the memory requirement of these two large bloom filters, GC often cannot process all the fingerprints in the file system and it has to perform a sampling procedure. Essentially that doubles the GC time.

The Live Vector is used in the select phase to evaluate the liveness of a container such that GC can select the emptiest containers for cleaning. It is then used in the copy phase to determine which segments must be copied forward. To compute the liveness of a container in the select phase, it is not necessary to know exactly which segments are alive. This information can be deduced from the dynamic duplicate estimation algorithm without using any Bloom filter. The perfect physical garbage collection (PPGC) algorithm independently adopts a new algorithm to remove duplicates in the copy phase without the live instance vector. By combining these two novel techniques, the Live Instance Vector can be removed, which allows the Live Vector to support twice the amount of fingerprints in the system. The PPGC algorithm also makes use of a more memory efficient perfect hash vector data structure instead of the bloom filter for the Live Vector. Altogether the sampling procedure is eliminated.

There are two versions of the algorithm. A first version of a dynamic duplication estimation algorithm is as follows.

Once the live vector has been formed, GC scans the index to retrieve the fingerprint sequences:

-   -   (FP, C0), (FP, C1), (FP, C2) . . . (FP, CN): C0<C1< . . . <CN

In the above equation, for each fingerprint FP, where C_(n) denotes the container ID, the GC process only keeps the newest segment (FP, CN) and considers the rest duplicates. It then consults the live vector to determine if FP is alive or dead. If the FP is alive, this implies the FP is a live duplicated segment in C0, C1, C(N−1). The process then defines an array D[c] where c is the container ID and D[c] is the number of live duplicated segments in the container. D can be constructed as described. For each of the fingerprint sequence:

-   -   (FP, C0), (FP, C1), (FP, C2) . . . (FP, CN): C0<C1< . . . <CN,     -   increment D[c] for c=0, 1, 2, . . . (N−1).

Once D has been constructed, the liveness of each container can be computed as follows: Liveness=L−D

In the above equation, L is the number of live segments in the container based on the live vector. This liveness is the number of unique live segments in the container, and is the same number that the live instance vector could provide.

A second version of the algorithm is as follows. The above algorithm requires a complete index scan in order to compute the array D, which can take several hours on large systems. The algorithm depends on the availability of the live vector. In the advanced version, the live vector is not needed. The array D can be constructed whenever the GC procedure has to scan the index. It indeed does so in order to build the perfect hash live vector. No extra index scan cycles are needed to build D. Since the live vector is not available, the array only contains the number of duplicates in the container and they can be either alive or dead. That specific information is revealed dynamically during the select phase.

The live duplicate counter keeps track of the number of live duplicated segments for each container. A live segment is a live duplicate segment if a segment with the same fingerprint exists in another container with higher CID.

Let L[CID] be the array of #live duplicates in container CID. This array can be built in two steps. Define D[CID] to be the number of duplicates for container CID as described above. During the analysis phase where the perfect hash functions are being created for the live vector, the index is scanned and it returns for each fingerprint a fingerprint sequence:

-   -   (FP, CID1), (FP, CID2) . . . (FP, CIDn) where CID1<=CID2<= . . .         <=CIDn

Only the last entry will be preserved and all the rest can be considered duplicates. Therefore D[CIDk] is incremented by one for k=1, 2, 3, . . . (n−1). The array D will container the number of duplicates but it includes both live duplicates and dead duplicates since the liveness of the segment is not known at this point.

In an embodiment, a live duplicate counter is used to keep track of the number of live duplicated segments for each container. For the operation of the live duplicate counter illustrated in FIGS. 9A-9B, a live segment is a live duplicate segment if a segment with the same fingerprint exists in another container with higher CID. This live duplicate counter is a sparse array, which can be implemented as a hash table or a perfect hash vector. With regard to notation, L[CID] denotes the array of #live duplicates in container CID. Once the live vector has been built after the enumeration phase, the index can be scanned again bucket by bucket to get the (FP, CID) pair records. For each fingerprint FP, the fingerprint sequence is extracted:

-   -   (FP, CID₁), (FP, CID₂) . . . (FP, CID_(n)) where CID₁<=CID₂<= .         . . <=CID_(n)

In a case where an FP is dead, the system ignores the FP. In a case where the FP is live, only the last entry will be kept and the rest are all duplicates. The value of L[CID_(k)] is incremented by one for k=1, 2, 3, . . . (n−1). CID_(k) corresponds to container ID where the duplicate is present.

After the live vector and the live duplicate counter are available, the number of unique live segments can be computed for each container. This can be expressed by the following: #Live segments in container CID−L[CID]

In general, the system cannot identify which live segments are duplicates at this point but all it needs is this liveness count per container to find out which containers to be considered candidates for copy forward and also to compute the total dead space in the system. The actual duplicate removal can be done in the copy forward phase.

The second version of the duplicate estimation can provide a precise number of live duplicate segments in a container but it requires an extra index scan. This overhead can be eliminated by the dynamic duplicate estimation algorithm. In an embodiment, the PPGC algorithm independently adopts a new algorithm to remove duplicates in the copy phase without the live instance vector. By combining these two novel techniques, the live instance vector can be removed, which allows the live vector to support twice the amount of fingerprints in the system. The PPGC algorithm also makes use of a more memory efficient perfect hash vector data structure instead of the bloom filter for the live vector. Altogether the sampling procedure is eliminated by this process.

In an embodiment, instead of the live duplicate counter, the system first builds the duplicate counter in the analysis phase. This counter only tracks the number of duplicated segments for each container. A segment is a duplicate segment if a segment with the same fingerprint exists in another container with higher CID. This counter includes both live and dead segments. Note that the live duplicate counter cannot be built in the analysis phase because the live vector is not available yet. For notation, let D[CID] be this duplicate counter for container CID.

This array is built in exactly the same way as the live duplicate counter except all fingerprints can be included regardless of its liveness. In the select phase, a Bloom filter called the dead vector is created to track the dead segments in the container set. After allocating memory for live vector and walk vector, the rest of the GC memory can be allocated to the dead segment vector. Containers can be scanned in the reverse order, i.e., from the highest CID to the lowest. Define n to be the number of bits set in the dead vector, and d to be number of dead duplicated segments in a container. For each dead segment in the container, if it is already set in the dead vector, increment d by 1. If it is not already in the dead vector, simply insert the fingerprint into the dead vector and increment n by 1. This Bloom filter is only need in the select phase and it can borrow all the remaining GC memory and return it after the select phase.

The total number of dead segments is much less than the total number of segments in the system and theoretically very little memory is needed to track all the dead segments. On a system such as Data Domain that has 24 GB of memory available for this Bloom filter, this is large enough to track 32 billion dead segments or 128 TB of dead space representing a churn rate of 25%. This dynamic duplicate estimate is very accurate when the collision rate is low in the Bloom filter. As the Bloom filter becomes full, the accuracy can drop and the algorithm can slowly assume a uniform distribution in the duplicates. The less accuracy the live duplicate estimate gets, the more dead segments GC have encountered.

If there is no collision in the dead vector, d would be the precise count of the dead duplicate segments. However, the probability of collision E of the bloom filter is known to be

$\left( {1 - \left\lbrack {1 - \frac{1}{m}} \right\rbrack^{kn}} \right)^{k} \approx {\left( {1 - e^{{- {kn}}/m}} \right)^{k}.}$ where m is the number of bits in the vector, and k is the number of hash function. Therefore, d*E of the dead segments might or might not be duplicates. It will be assumed that they are uniformly distributed. The adjust number of dead duplicate segments is equal to: d*(1−E)+d*E*(% of dead segments in the container)=d−d*E*(1−% dead segments)=d*(1−E*% live segments) The estimated live duplicates will be equal to L[CID]=Number of duplicates−number of dead duplicates=D[CID]−d*(1−E*% live segments) The liveness (without dups) of the container is therefore #Live segments−L[CID]=#Live segments−(D[CID]−d*(1−E*% live segments))

Note that if E is 0, the process provides a very accurate estimate of L. If E is 1, the algorithm is reduced to the uniform distribution assumption of the duplicates. The significance of this algorithm is that it eliminates the filter phase and the index scan associated with it. Various different data structures may be defined and used in the PPGC system. In general, the data structures used in PPGC can be much simpler than PGC and all the structures can be allocated once statically. Also, there are generally no convoluted dynamic memory allocation issues like in PGC.

Computer System

The network of FIG. 1 may comprise any number of individual client-server networks coupled over the Internet or similar large-scale network or portion thereof. Each node in the network(s) comprises a computing device capable of executing software code to perform the processing steps described herein. FIG. 10 shows a system block diagram of a computer system used to execute one or more software components of the present system described herein. The computer system 1005 includes a monitor 1011, keyboard 1017, and mass storage devices 1020. Computer system 1005 further includes subsystems such as central processor 1010, system memory 1015, input/output (I/O) controller 1021, display adapter 1025, serial or universal serial bus (USB) port 1030, network interface 1035, and speaker 1040. The system may also be used with computer systems with additional or fewer subsystems. For example, a computer system could include more than one processor 1010 (i.e., a multiprocessor system) or a system may include a cache memory.

Arrows such as 1045 represent the system bus architecture of computer system 1005. However, these arrows are illustrative of any interconnection scheme serving to link the subsystems. For example, speaker 1040 could be connected to the other subsystems through a port or have an internal direct connection to central processor 1010. The processor may include multiple processors or a multicore processor, which may permit parallel processing of information. Computer system 1005 shown in FIG. 10 is but an example of a computer system suitable for use with the present system. Other configurations of subsystems suitable for use with the present invention will be readily apparent to one of ordinary skill in the art.

Computer software products may be written in any of various suitable programming languages. The computer software product may be an independent application with data input and data display modules. Alternatively, the computer software products may be classes that may be instantiated as distributed objects. The computer software products may also be component software.

An operating system for the system may be one of the Microsoft Windows®. family of systems (e.g., Windows Server), Linux, Mac OS X, IRIX32, or IRIX64. Other operating systems may be used. Microsoft Windows is a trademark of Microsoft Corporation.

Furthermore, the computer may be connected to a network and may interface to other computers using this network. The network may be an intranet, Internet, or the Internet, among others. The network may be a wired network (e.g., using copper), telephone network, packet network, an optical network (e.g., using optical fiber), or a wireless network, or any combination of these. For example, data and other information may be passed between the computer and components (or steps) of a system of the invention using a wireless network using a protocol such as Wi-Fi (IEEE standards 802.11, 802.11a, 802.11b, 802.11e, 802.11g, 802.11i, 802.11n, 802.11ac, and 802.11ad, just to name a few examples), near field communication (NFC), radio-frequency identification (RFID), mobile or cellular wireless. For example, signals from a computer may be transferred, at least in part, wirelessly to components or other computers.

In an embodiment, with a web browser executing on a computer workstation system, a user accesses a system on the World Wide Web (WWW) through a network such as the Internet. The web browser is used to download web pages or other content in various formats including HTML, XML, text, PDF, and postscript, and may be used to upload information to other parts of the system. The web browser may use uniform resource identifiers (URLs) to identify resources on the web and hypertext transfer protocol (HTTP) in transferring files on the web.

In other implementations, the user accesses the system through either or both of native and nonnative applications. Native applications are locally installed on the particular computing system and are specific to the operating system or one or more hardware devices of that computing system, or a combination of these. These applications can be updated (e.g., periodically) via a direct Internet upgrade patching mechanism or through an applications store (e.g., Apple iTunes and App store, Google Play store, and Windows Phone App store).

The system can run in platform-independent, nonnative applications. For example, client can access the system through a web application from one or more servers using a network connection with the server or servers and load the web application in a web browser. For example, a web application can be downloaded from an application server over the Internet by a web browser. Nonnative applications can also be obtained from other sources, such as a disk.

For the sake of clarity, the processes and methods herein have been illustrated with a specific flow, but it should be understood that other sequences may be possible and that some may be performed in parallel, without departing from the spirit of the invention. Additionally, steps may be subdivided or combined. As disclosed herein, software written in accordance with the present invention may be stored in some form of computer-readable medium, such as memory or CD-ROM, or transmitted over a network, and executed by a processor. More than one computer may be used, such as by using multiple computers in a parallel or load-sharing arrangement or distributing tasks across multiple computers such that, as a whole, they perform the functions of the components identified herein; i.e. they take the place of a single computer. Various functions described above may be performed by a single process or groups of processes, on a single computer or distributed over several computers. Processes may invoke other processes to handle certain tasks. A single storage device may be used, or several may be used to take the place of a single storage device.

Unless the context clearly requires otherwise, throughout the description and the claims, the words “comprise,” “comprising,” and the like are to be construed in an inclusive sense as opposed to an exclusive or exhaustive sense; that is to say, in a sense of “including, but not limited to.” Words using the singular or plural number also include the plural or singular number respectively. Additionally, the words “herein,” “hereunder,” “above,” “below,” and words of similar import refer to this application as a whole and not to any particular portions of this application. When the word “or” is used in reference to a list of two or more items, that word covers all of the following interpretations of the word: any of the items in the list, all of the items in the list and any combination of the items in the list.

All references cited herein are intended to be incorporated by reference. While one or more implementations have been described by way of example and in terms of the specific embodiments, it is to be understood that one or more implementations are not limited to the disclosed embodiments. To the contrary, it is intended to cover various modifications and similar arrangements as would be apparent to those skilled in the art. Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements. 

What is claimed is:
 1. A computer-implemented method of dynamically estimating duplicate containers in a garbage collection process for use in a deduplication backup system, comprising: scanning, in an analysis phase of the garbage collection process, an index containing a mapping of fingerprints to a sequentially numbered container ID (CID) for a plurality of containers; returning, for each fingerprint, a fingerprint sequence associating each fingerprint with a respective unique container ID, wherein a last entry of the sequence is preserved and the remaining entries are considered duplicates; and maintaining a duplicate array of container IDs indexed by an incremental count, wherein the incremental count is incremented for each of the container IDs, and wherein the duplicate array comprises a duplicate counter that keeps track of a number of live duplicated segments for each container, and further wherein a live segment is a live duplicate segment if a segment with a same fingerprint exists in another container with a higher container ID number relative to other container IDs.
 2. The method of claim 1 further comprising tracking, in a select phase of the garbage collection process, dead segments in a dead vector by scanning in reverse numerical order the containers of the plurality of containers from the highest numbered CID to the lowest numbered CID.
 3. The method of claim 2 further comprising: determining if a segment in a container is a dead segment; checking the dead vector to see if the fingerprint is present, and if so, incrementing the count of dead segments in CID by one; and if the dead fingerprint is not present in the dead vector, then adding it to the dead vector.
 4. The method of claim 3 wherein the dead vector is implemented using a Bloom filter.
 5. The method of claim 4 further comprising determining if there is a collision in the dead vector, and if not taking the dead segment count to be the exact number of dead duplicate segments.
 6. The method of claim 5 further comprising using a probability of collision of the Bloom filter to produce a dead duplicate estimate based on a uniform distribution function that is a function of the duplicate array multiplied by a percentage of dead segments.
 7. The method of claim 6 wherein an estimate of live duplicates is determined by subtracting a number of dead duplicate segments from a total number of duplicate segments.
 8. The method of claim 7 wherein a liveness of a container is estimated by subtracting an array of live duplicates from a total number of live segments.
 9. The method of claim 8 wherein the estimate of the liveness of a container is used in a perfect physical garbage collection (PPGC) process using a perfect hash live vector with a live vector comprising a perfect hash vector, and no live instance vector.
 10. The method of claim 9 wherein the liveness of the container is used by the PPGC during traversal of the plurality of containers in the select phase to select containers that meet a defined liveness threshold prior to copying forward, in a copy phase, live segments out of the selected containers.
 11. A system implementing perfect physical garbage collection (PPGC) within a deduplication backup network by dynamically estimating duplicate containers in a garbage collection process for use in a deduplication backup system, comprising: a first component scanning, in an analysis phase of the garbage collection process, an index containing a mapping of fingerprints to a sequentially numbered container ID (CID) for a plurality of containers, and returning, for each fingerprint, a fingerprint sequence associating each fingerprint with a respective unique container ID, wherein a last entry of the sequence is preserved and the remaining entries are considered duplicates; and a second component maintaining a duplicate array of container IDs indexed by an incremental count, wherein the incremental count is incremented for each of the container IDs, and wherein the duplicate array comprises a duplicate counter that keeps track of a number of live duplicated segments for each container, and further wherein a live segment is a live duplicate segment if a segment with a same fingerprint exists in another container with a higher container ID number relative to other container IDs.
 12. The system of claim 11 further comprising tracking component tracking, in a select phase of the garbage collection process, dead segments in a dead vector by scanning in reverse numerical order the containers of the plurality of containers from the highest numbered CID to the lowest numbered CID.
 13. The system of claim 12 wherein the dead vector is implemented using a Bloom filter, and further comprising: a third component determining if a segment in a container is dead, and if so incrementing a dead segment count for the dead vector by one, and if not inserting the corresponding fingerprint in the dead vector and incrementing a CID count by one.
 14. The system of claim 13 wherein the third component further determines if there is a collision in the dead vector, and if not taking the dead segment count to be the exact number of dead duplicate segments, and using a probability of collision of the Bloom filter to produce a dead duplicate estimate based on a uniform distribution function that is a function of the duplicate array multiplied by a percentage of dead segments.
 15. The system of claim 14 wherein an estimate of live duplicates is determined by subtracting a number of dead duplicate segments from a total number of duplicate segments, and further wherein a liveness of a container is estimated by subtracting an array of live duplicates from a total number of live segments.
 16. The system of claim 15 wherein the estimate of the liveness of a container is used in a perfect physical garbage collection (PPGC) process using a perfect hash live vector with a live vector comprising a perfect hash vector, and no live instance vector.
 17. The system of claim 16 wherein the liveness of the container is used by the PPGC during traversal of the plurality of containers in the select phase to select containers that meet a defined liveness threshold prior to copying forward, in a copy phase, live segments out of the selected containers.
 18. A computer program product, comprising a non-transitory computer-readable medium having a computer-readable program code embodied therein, the computer-readable program code adapted to be executed by one or more processors to implement a method of performing perfect physical garbage collection for use in a deduplication backup system that dynamically estimates duplicate containers, by: scanning, in an analysis phase of the garbage collection process, an index containing a mapping of fingerprints to a sequentially numbered container ID (CID) for a plurality of containers; returning, for each fingerprint, a fingerprint sequence associating each fingerprint with a respective unique container ID, wherein a last entry of the sequence is preserved and the remaining entries are considered duplicates; and maintaining a duplicate array of container IDs indexed by an incremental count, wherein the incremental count is incremented for each of the container IDs, and wherein the duplicate array comprises a duplicate counter that keeps track of a number of live duplicated segments for each container, and further wherein a live segment is a live duplicate segment if a segment with a same fingerprint exists in another container with a higher container ID number relative to other CIDs.
 19. The computer program product of claim 18, wherein the method further comprises tracking, in a select phase of the garbage collection process, dead segments in a dead vector by scanning in reverse numerical order the containers of the plurality of containers from the highest numbered CID to the lowest numbered CID.
 20. The computer program product of claim 19, wherein the method further comprises: determining if a segment in a container is a dead segment; checking the dead vector to see if the fingerprint is present, and if so, incrementing the count of dead segments in CID by one; and if the dead fingerprint is not present in the dead vector, then adding it to the dead vector. 